use anyhow::Result;
use std::time::Duration;
use std::thread;

mod ftp_client_test;
use ftp_client_test::FtpTestClient;

/// 错误场景测试套件
pub struct ErrorScenarioTestSuite;

impl ErrorScenarioTestSuite {
    pub fn new() -> Self {
        Self
    }
    
    /// 测试网络错误
    pub fn test_network_errors(&self) -> Result<()> {
        println!("\n=== 测试网络错误 ===");
        
        // 测试连接不存在的服务器
        println!("测试连接不存在的服务器...");
        match FtpTestClient::connect("nonexistent.server", 21) {
            Ok(_) => println!("❌ 应该连接失败"),
            Err(_) => println!("✅ 正确拒绝不存在的服务器"),
        }
        
        // 测试连接错误的端口
        println!("测试连接错误的端口...");
        match FtpTestClient::connect("localhost", 9999) {
            Ok(_) => println!("❌ 应该连接失败"),
            Err(_) => println!("✅ 正确拒绝错误的端口"),
        }
        
        Ok(())
    }
    
    /// 测试认证错误
    pub fn test_authentication_errors(&self) -> Result<()> {
        println!("\n=== 测试认证错误 ===");
        
        let mut client = FtpTestClient::connect("localhost", 2121)?;
        client.read_response()?;
        
        // 测试空用户名
        println!("测试空用户名...");
        client.send_command("USER")?;
        match client.expect_response(501) {
            Ok(_) => println!("✅ 空用户名正确被拒绝"),
            Err(_) => println!("❌ 空用户名未被正确拒绝"),
        }
        
        // 测试空密码
        println!("测试空密码...");
        client.send_command("USER testuser")?;
        client.expect_response(331)?;
        client.send_command("PASS")?;
        match client.expect_response(501) {
            Ok(_) => println!("✅ 空密码正确被拒绝"),
            Err(_) => println!("❌ 空密码未被正确拒绝"),
        }
        
        // 测试错误的用户名格式
        println!("测试错误的用户名格式...");
        client.send_command("USER user@domain")?;
        match client.expect_response(331) {
            Ok(_) => {
                client.send_command("PASS wrongpass")?;
                match client.expect_response(530) {
                    Ok(_) => println!("✅ 错误用户名格式正确被拒绝"),
                    Err(_) => println!("❌ 错误用户名格式未被正确拒绝"),
                }
            }
            Err(_) => println!("✅ 错误用户名格式直接被拒绝"),
        }
        
        client.send_command("QUIT")?;
        client.expect_response(221)?;
        
        Ok(())
    }
    
    /// 测试命令错误
    pub fn test_command_errors(&self) -> Result<()> {
        println!("\n=== 测试命令错误 ===");
        
        let mut client = FtpTestClient::connect("localhost", 2121)?;
        client.read_response()?;
        client.login("testuser", "testpass")?;
        
        // 测试无效命令
        println!("测试无效命令...");
        client.send_command("INVALID_COMMAND")?;
        match client.expect_response(500) {
            Ok(_) => println!("✅ 无效命令正确被拒绝"),
            Err(_) => println!("❌ 无效命令未被正确拒绝"),
        }
        
        // 测试命令参数错误
        println!("测试命令参数错误...");
        client.send_command("USER")?;
        match client.expect_response(501) {
            Ok(_) => println!("✅ 缺少参数正确被拒绝"),
            Err(_) => println!("❌ 缺少参数未被正确拒绝"),
        }
        
        // 测试PORT命令格式错误
        println!("测试PORT命令格式错误...");
        client.send_command("PORT invalid_format")?;
        match client.expect_response(501) {
            Ok(_) => println!("✅ PORT格式错误正确被拒绝"),
            Err(_) => println!("❌ PORT格式错误未被正确拒绝"),
        }
        
        // 测试TYPE命令参数错误
        println!("测试TYPE命令参数错误...");
        client.send_command("TYPE X")?;
        match client.expect_response(501) {
            Ok(_) => println!("✅ TYPE参数错误正确被拒绝"),
            Err(_) => println!("❌ TYPE参数错误未被正确拒绝"),
        }
        
        client.send_command("QUIT")?;
        client.expect_response(221)?;
        
        Ok(())
    }
    
    /// 测试文件操作错误
    pub fn test_file_operation_errors(&self) -> Result<()> {
        println!("\n=== 测试文件操作错误 ===");
        
        let mut client = FtpTestClient::connect("localhost", 2121)?;
        client.read_response()?;
        client.login("testuser", "testpass")?;
        
        // 测试不存在的文件
        println!("测试不存在的文件...");
        client.send_command("SIZE nonexistent.txt")?;
        match client.expect_response(550) {
            Ok(_) => println!("✅ 不存在文件正确被拒绝"),
            Err(_) => println!("❌ 不存在文件未被正确拒绝"),
        }
        
        // 测试不存在的目录
        println!("测试不存在的目录...");
        client.send_command("CWD nonexistent_dir")?;
        match client.expect_response(550) {
            Ok(_) => println!("✅ 不存在目录正确被拒绝"),
            Err(_) => println!("❌ 不存在目录未被正确拒绝"),
        }
        
        // 测试无效的文件名
        println!("测试无效的文件名...");
        client.send_command("SIZE /invalid/path/file.txt")?;
        match client.expect_response(550) {
            Ok(_) => println!("✅ 无效文件名正确被拒绝"),
            Err(_) => println!("❌ 无效文件名未被正确拒绝"),
        }
        
        client.send_command("QUIT")?;
        client.expect_response(221)?;
        
        Ok(())
    }
    
    /// 测试权限错误
    pub fn test_permission_errors(&self) -> Result<()> {
        println!("\n=== 测试权限错误 ===");
        
        // 测试未认证的命令
        println!("测试未认证的命令...");
        let mut client = FtpTestClient::connect("localhost", 2121)?;
        client.read_response()?;
        
        let protected_commands = vec!["PWD", "LIST", "STOR", "RETR", "DELE"];
        
        for cmd in protected_commands {
            client.send_command(cmd)?;
            match client.expect_response(530) {
                Ok(_) => println!("✅ 未认证命令 {} 正确被拒绝", cmd),
                Err(_) => println!("❌ 未认证命令 {} 未被正确拒绝", cmd),
            }
        }
        
        client.send_command("QUIT")?;
        client.expect_response(221)?;
        
        Ok(())
    }
    
    /// 测试协议错误
    pub fn test_protocol_errors(&self) -> Result<()> {
        println!("\n=== 测试协议错误 ===");
        
        let mut client = FtpTestClient::connect("localhost", 2121)?;
        client.read_response()?;
        client.login("testuser", "testpass")?;
        
        // 测试REST命令的无效参数
        println!("测试REST命令的无效参数...");
        client.send_command("REST invalid")?;
        match client.expect_response(501) {
            Ok(_) => println!("✅ REST无效参数正确被拒绝"),
            Err(_) => println!("❌ REST无效参数未被正确拒绝"),
        }
        
        // 测试MDTM命令的无效格式
        println!("测试MDTM命令的无效格式...");
        client.send_command("MDTM")?;
        match client.expect_response(501) {
            Ok(_) => println!("✅ MDTM缺少参数正确被拒绝"),
            Err(_) => println!("❌ MDTM缺少参数未被正确拒绝"),
        }
        
        client.send_command("QUIT")?;
        client.expect_response(221)?;
        
        Ok(())
    }
    
    /// 测试连接中断
    pub fn test_connection_interruption(&self) -> Result<()> {
        println!("\n=== 测试连接中断 ===");
        
        // 测试客户端主动断开连接
        println!("测试客户端主动断开连接...");
        let mut client = FtpTestClient::connect("localhost", 2121)?;
        client.read_response()?;
        client.login("testuser", "testpass")?;
        
        // 发送QUIT命令
        client.send_command("QUIT")?;
        match client.expect_response(221) {
            Ok(_) => println!("✅ 正常断开连接"),
            Err(_) => println!("❌ 断开连接失败"),
        }
        
        // 测试在连接断开后发送命令
        println!("测试在连接断开后发送命令...");
        match client.send_command("NOOP") {
            Ok(_) => {
                match client.read_response() {
                    Ok(_) => println!("❌ 应该无法发送命令"),
                    Err(_) => println!("✅ 正确拒绝断开连接后的命令"),
                }
            }
            Err(_) => println!("✅ 正确拒绝断开连接后的命令"),
        }
        
        Ok(())
    }
    
    /// 测试超时场景
    pub fn test_timeout_scenarios(&self) -> Result<()> {
        println!("\n=== 测试超时场景 ===");
        
        let mut client = FtpTestClient::connect("localhost", 2121)?;
        client.read_response()?;
        client.login("testuser", "testpass")?;
        
        // 测试长时间无响应
        println!("测试长时间无响应...");
        client.send_command("NOOP")?;
        match client.expect_response(200) {
            Ok(_) => println!("✅ 服务器正常响应"),
            Err(_) => println!("❌ 服务器响应异常"),
        }
        
        // 测试连续发送命令
        println!("测试连续发送命令...");
        for i in 0..10 {
            client.send_command("NOOP")?;
            match client.expect_response(200) {
                Ok(_) => println!("✅ 命令 {} 正常响应", i),
                Err(_) => println!("❌ 命令 {} 响应异常", i),
            }
        }
        
        client.send_command("QUIT")?;
        client.expect_response(221)?;
        
        Ok(())
    }
    
    /// 运行完整错误场景测试
    pub fn run_error_scenario_test(&self) -> Result<()> {
        println!("🚀 开始错误场景测试");
        
        self.test_network_errors()?;
        self.test_authentication_errors()?;
        self.test_command_errors()?;
        self.test_file_operation_errors()?;
        self.test_permission_errors()?;
        self.test_protocol_errors()?;
        self.test_connection_interruption()?;
        self.test_timeout_scenarios()?;
        
        println!("✅ 错误场景测试完成");
        Ok(())
    }
}

fn main() -> Result<()> {
    let test_suite = ErrorScenarioTestSuite::new();
    test_suite.run_error_scenario_test()
}
